package com.hexingmo.dawn.lang;

/**
 * 表示 Java 不同版本的枚举定义，涵盖从 JDK 1.0 到未来的 Java SE 版本信息。<br>
 * <a href="https://zh.wikipedia.org/wiki/Java%E7%89%88%E6%9C%AC%E6%AD%B7%E5%8F%B2">wiki Java版本历史</a> <br>
 * <a href="https://docs.oracle.com/en/java/javase/index.html">javase版本</a> <br>
 * <a href="https://jcp.org/">JCP</a> <br>
 *
 * <p>自 JDK 1.0 版本以来，Java 经历了多次重大更新，并逐步引入新特性与改进。
 * 自 J2SE 1.4 起，Java 的演进由 Java Community Process (JCP) 管理，通过 Java
 * Specification Requests (JSRs) 来推动平台的发展。</p>
 *
 * <p>该枚举主要用于表示 Java 版本的基本信息，包括：</p>
 * <ul>
 *   <li>版本名称（如 "1.8", "11"）</li>
 *   <li>版本号浮点值（用于排序或比较）</li>
 *   <li>对应的 Class 文件主版本号（可用于编译/运行兼容性判断）</li>
 *   <li>发布年份</li>
 * </ul>
 *
 * @author He Xing Mo
 * @since 1.0
 */
public enum JavaVersion {

    /**
     * 未知版本
     */
    JAVA_UNKNOWN("unknown" , -1.0f, -1 , -1),

    /**
     * 1996 年 JDK 1.0 发布
     */
    JAVA_1_0("1.0" , 1.0f, 44,1996),

    /**
     * 1997 年 JDK 1.1 发布
     */
    JAVA_1_1("1.1" , 1.1f, 45 , 1997),

    /**
     * 1998 年 12 月 4 日 JDK 1.2 发布
     */
    JAVA_1_2("1.2" , 1.2f , 46 , 1998),

    /**
     * 2000 年 5 月 8 日 JDK 1.3 发布
     */
    JAVA_1_3("1.3" , 1.3f, 47 , 2000),

    /**
     * 2002 年 2 月 13 日 JDK 1.4 发布。
     * <a href="https://www.jcp.org/en/jsr/detail?id=59">JSR 59</a>
     */
    JAVA_1_4("1.4" , 1.4f, 48 , 2000),

    /**
     * 2004 年 9 月 30 日 JDK 1.5 (J2SE 5.0) 发布。<br>
     * <a href="https://docs.oracle.com/javase/1.5.0/docs/">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=176">JSR 176</a>
     */
    JAVA_1_5("1.5" , 1.5f, 49 , 2004),

    /**
     * 2006 年 12 月 11 JDK 1.6 (Java SE 6) 发布。<br>
     * <a href="https://docs.oracle.com/javase/6/docs/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=270">JSR 270</a>
     */
    JAVA_1_6("1.6" , 1.6f, 50 , 2006),

    /**
     * 2011 年 7 月 28 日 JDK 1.7 (Java SE 7) 发布。<br>
     * <a href="https://docs.oracle.com/javase/7/docs/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=336">JSR 336</a>
     */
    JAVA_1_7("1.7" , 1.7f, 51 , 2011),

    /**
     * 2014 年 3 月 18 日 JDK 1.8 (Java SE 8) 发布。<br>
     * LTS (Long-term support) 长期支持版本 。<br>
     * <a href="https://docs.oracle.com/javase/8/docs/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=337">JSR 337</a>
     */
    JAVA_1_8("1.8" , 1.8f, 52 , 2014),

    /**
     * 2017 年 9 月 21 日 JDK 9 (Java SE 9) 发布。<br>
     * <a href="https://docs.oracle.com/javase/9/">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=379">JSR 379</a>
     */
    JAVA_9("9" , 9.0f, 53 , 2017),

    /**
     * 2018 年 3 月 20 日 JDK 10 (Java SE 10) 发布。<br>
     * <a href="https://docs.oracle.com/javase/10/">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=383">JSR 383</a>
     */
    JAVA_10("10" , 10.0f, 54 , 2018),

    /**
     * 2018 年 9 月 25 日 JDK 11 (Java SE 11) 发布。<br>
     * LTS (Long-term support) 长期支持版本 。<br>
     * <a href="https://docs.oracle.com/en/java/javase/11/">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=384">JSR 384</a>
     */
    JAVA_11("11" , 11.0f, 55 , 2018),

    /**
     * 2019 年 3 月 19 日 JDK 12 (Java SE 12) 发布。<br>
     * <a href="https://docs.oracle.com/en/java/javase/12/">官方文档</a>
     */
    JAVA_12("12" , 12.0f, 56 , 2019),

    /**
     * 2019 年 9 月 17 日 JDK 13 (Java SE 13) 发布。<br>
     * <a href="https://docs.oracle.com/en/java/javase/13/">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=388">JSR 388</a>
     */
    JAVA_13("13" , 13.0f, 57 , 2019),

    /**
     * 2020 年 3 月 17 日 JDK 14 (Java SE 14) 发布。<br>
     * <a href="https://docs.oracle.com/en/java/javase/14/">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=389">JSR 389</a>
     */
    JAVA_14("14" , 14.0f, 58 , 2020),

    /**
     * 2020 年 9 月 16 日 JDK 15 (Java SE 15) 发布。<br>
     * <a href="https://docs.oracle.com/en/java/javase/15/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=390">JSR 390</a>
     */
    JAVA_15("15" , 15.0f, 59 , 2020),

    /**
     * 2021 年 3 月 16 日 JDK 16 (Java SE 16) 发布。<br>
     * <a href="https://docs.oracle.com/en/java/javase/16/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=391">JSR 391</a>
     */
    JAVA_16("16" , 16.0f, 60 , 2021),

    /**
     * 2021 年 9 月 14 日 JDK 17 (Java SE 17) 发布。<br>
     * LTS (Long-term support) 长期支持版本 。<br>
     * <a href="https://docs.oracle.com/en/java/javase/17/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=392">JSR 392</a>
     */
    JAVA_17("17" , 17.0f, 61 , 2021),

    /**
     * 2022 年 3 月 22 日 JDK 18 (Java SE 18) 发布。<br>
     * <a href="https://docs.oracle.com/en/java/javase/18/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=393">JSR 393</a>
     */
    JAVA_18("18" , 18.0f, 62 , 2022),

    /**
     * 2022 年 9 月 20 日 JDK 19 (Java SE 19) 发布。<br>
     * <a href="https://docs.oracle.com/en/java/javase/19/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=394">JSR 394</a>
     */
    JAVA_19("19" , 19.0f, 63 , 2022),

    /**
     * 2023 年 3 月 21 日 JDK 20 (Java SE 20) 发布。<br>
     * <a href="https://docs.oracle.com/en/java/javase/20/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=395">JSR 395</a>
     */
    JAVA_20("20" , 20.0f, 64 , 2023),

    /**
     * 2023 年 9 月 19 日 JDK 21 (Java SE 21) 发布。<br>
     * LTS (Long-term support) 长期支持版本 。<br>
     * <a href="https://docs.oracle.com/en/java/javase/21/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=396">JSR 396</a>
     */
    JAVA_21("21" , 21.0f, 65 , 2023),


    /**
     * 2024 年 3 月 19 日 JDK 22 (Java SE 22) 发布。<br>
     * <a href="https://docs.oracle.com/en/java/javase/22/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=397">JSR 397</a>
     */
    JAVA_22("22" , 22.0f, 66 , 2023),

    /**
     * 2024 年 9 月 17 日 JDK 23 (Java SE 23) 发布。<br>
     * <a href="https://docs.oracle.com/en/java/javase/23/index.html">官方文档</a>
     * <a href="https://jcp.org/en/jsr/detail?id=398">JSR 398</a>
     */
    JAVA_23("23" , 23.0f, 67 , 2024),

    /**
     * 2025 年 3 月 18 日 JDK 23 (Java SE 24) 发布。<br>
     * <a href="https://docs.oracle.com/en/java/javase/24/index.html">官方文档</a> <br>
     * <a href="https://jcp.org/en/jsr/detail?id=399">JSR 399</a>
     */
    JAVA_24("24" , 24.0f, 68 , 2025),

    /**
     * 2025 年 9 月 JDK 25 (Java SE 25) 发布。<br>
     * <a href="https://jcp.org/en/jsr/detail?id=400">JSR 400</a>
     */
    JAVA_25("25" , 25.0f, 69 , 2025),
    ;



    private final String name;

    private final float value;

    private final int classVersion;

    private final int releaseYear;

    JavaVersion(String name, float value, int classVersion ,int releaseYear) {
        this.name = name;
        this.value = value;
        this.classVersion = classVersion;
        this.releaseYear = releaseYear;
    }

    public String getName() {
        return name;
    }

    public float getValue() {
        return value;
    }

    public int getClassVersion() {
        return classVersion;
    }

    public int getReleaseYear() {
        return releaseYear;
    }

    /**
     * 根据版本字符串获取对应的 JavaVersion 枚举实例。
     *
     * <p>支持的版本格式包括：</p>
     * <ul>
     *   <li>JDK 1.4 ~ 1.8 的格式（如 "1.5", "1.8"）</li>
     *   <li>JDK 9 及以后的简化格式（如 "9", "11"）</li>
     * </ul>
     *
     * <p>如果传入的版本字符串不匹配任何已知版本，则返回 null 或 JAVA_UNKNOWN（如有定义）。</p>
     *
     * @param version 要匹配的 Java 版本字符串，例如："1.8"、"11"、"25"
     * @return 对应的 JavaVersion 枚举实例，若未找到匹配项则返回预定义的未知版本枚举
     */
    public static JavaVersion get(final String version) {
        if (version == null) {
            return null;
        }
        switch (version) {
            case "1.1":
                return JAVA_1_1;
            case "1.2":
                return JAVA_1_2;
            case "1.3":
                return JAVA_1_3;
            case "1.4":
                return JAVA_1_4;
            case "1.5":
                return JAVA_1_5;
            case "1.6":
                return JAVA_1_6;
            case "1.7":
                return JAVA_1_7;
            case "1.8":
                return JAVA_1_8;
            case "9":
                return JAVA_9;
            case "10":
                return JAVA_10;
            case "11":
                return JAVA_11;
            case "12":
                return JAVA_12;
            case "13":
                return JAVA_13;
            case "14":
                return JAVA_14;
            case "15":
                return JAVA_15;
            case "16":
                return JAVA_16;
            case "17":
                return JAVA_17;
            case "18":
                return JAVA_18;
            case "19":
                return JAVA_19;
            case "20":
                return JAVA_20;
            case "21":
                return JAVA_21;
            case "22":
                return JAVA_22;
            case "23":
                return JAVA_23;
            case "24":
                return JAVA_24;
            case "25":
                return JAVA_25;
            default:
                return JAVA_UNKNOWN;
        }
    }

    /**
     * 根据类文件版本号获取对应的 JavaVersion 枚举实例
     *
     * @param classVersion 类文件版本号（如 52 对应 Java 8）
     * @return 对应的 JavaVersion 枚举实例，若未找到匹配项则返回 JAVA_UNKNOWN
     */
    public static JavaVersion getByClassVersion(int classVersion) {
        for (JavaVersion version : values()) {
            if (version.getClassVersion() == classVersion) {
                return version;
            }
        }
        return JAVA_UNKNOWN;
    }

    /**
     * 根据浮点版本值获取对应的 JavaVersion 枚举实例
     *
     * @param value 浮点版本值（如 1.8f 对应 Java 8）
     * @return 对应的 JavaVersion 枚举实例，若未找到匹配项则返回 JAVA_UNKNOWN
     */
    public static JavaVersion getByValue(float value) {
        for (JavaVersion version : values()) {
            if (Float.compare(version.getValue(), value) == 0) {
                return version;
            }
        }
        return JAVA_UNKNOWN;
    }

    /**
     * 根据发布年份获取对应的 JavaVersion 枚举实例
     *
     * @param releaseYear 发布年份
     * @return 对应的 JavaVersion 枚举实例，若未找到匹配项则返回 JAVA_UNKNOWN
     */
    public static JavaVersion getByReleaseYear(int releaseYear) {
        for (JavaVersion version : values()) {
            if (version.getReleaseYear() == releaseYear) {
                return version;
            }
        }
        return JAVA_UNKNOWN;
    }

    /**
     * 获取当前运行时的 Java 版本
     *
     * @return 当前运行时的 JavaVersion 枚举实例
     */
    public static JavaVersion getCurrent() {
        String version = System.getProperty("java.version");
        return get(version);
    }

    /**
     * 获取当前运行时的 Java 规范版本
     *
     * @return 当前运行时的 JavaVersion 枚举实例
     */
    public static JavaVersion getCurrentSpecification() {
        return get(SystemUtils.getJavaSpecificationVersion());
    }

    /**
     * 获取当前运行时的 Java 类版本
     *
     * @return 当前运行时的 JavaVersion 枚举实例
     */
    public static JavaVersion getCurrentClassVersion() {
        String classVersion = SystemUtils.getJavaClassVersion();
        if (classVersion != null) {
            try {
                int version = (int) Double.parseDouble(classVersion);
                return getByClassVersion(version);
            } catch (NumberFormatException e) {
                return JAVA_UNKNOWN;
            }
        }
        return JAVA_UNKNOWN;
    }

    /**
     * 获取所有 LTS（长期支持）版本
     *
     * @return LTS 版本的 JavaVersion 数组
     */
    public static JavaVersion[] getLtsVersions() {
        return new JavaVersion[]{
                JAVA_1_8,   // Java 8 LTS
                JAVA_11,    // Java 11 LTS
                JAVA_17,    // Java 17 LTS
                JAVA_21     // Java 21 LTS
        };
    }

    /**
     * 判断当前版本是否为 LTS（长期支持）版本
     *
     * @return 如果是 LTS 版本返回 true，否则返回 false
     */
    public boolean isLts() {
        JavaVersion[] ltsVersions = getLtsVersions();
        for (JavaVersion ltsVersion : ltsVersions) {
            if (this == ltsVersion) {
                return true;
            }
        }
        return false;
    }

    /**
     * 获取所有已发布的版本（按时间顺序）
     *
     * @return 所有已发布版本的 JavaVersion 数组
     */
    public static JavaVersion[] getAllReleasedVersions() {
        return new JavaVersion[]{
                JAVA_1_0, JAVA_1_1, JAVA_1_2, JAVA_1_3, JAVA_1_4,
                JAVA_1_5, JAVA_1_6, JAVA_1_7, JAVA_1_8, JAVA_9,
                JAVA_10, JAVA_11, JAVA_12, JAVA_13, JAVA_14,
                JAVA_15, JAVA_16, JAVA_17, JAVA_18, JAVA_19,
                JAVA_20, JAVA_21, JAVA_22, JAVA_23, JAVA_24, JAVA_25
        };
    }

    /**
     * 获取最新的 LTS 版本
     *
     * @return 最新的 LTS 版本
     */
    public static JavaVersion getLatestLts() {
        JavaVersion[] ltsVersions = getLtsVersions();
        return ltsVersions[ltsVersions.length - 1];
    }

    /**
     * 获取最新发布的版本
     *
     * @return 最新发布的版本
     */
    public static JavaVersion getLatest() {
        JavaVersion[] allVersions = getAllReleasedVersions();
        return allVersions[allVersions.length - 1];
    }

    /**
     * 比较两个版本，判断当前版本是否大于指定版本
     *
     * @param other 要比较的版本
     * @return 如果当前版本大于指定版本返回 true，否则返回 false
     */
    public boolean isGreaterThan(JavaVersion other) {
        return this.getValue() > other.getValue();
    }

    /**
     * 比较两个版本，判断当前版本是否小于指定版本
     *
     * @param other 要比较的版本
     * @return 如果当前版本小于指定版本返回 true，否则返回 false
     */
    public boolean isLessThan(JavaVersion other) {
        return this.getValue() < other.getValue();
    }

    /**
     * 比较两个版本，判断当前版本是否大于等于指定版本
     *
     * @param other 要比较的版本
     * @return 如果当前版本大于等于指定版本返回 true，否则返回 false
     */
    public boolean isGreaterThanOrEqualTo(JavaVersion other) {
        return this.getValue() >= other.getValue();
    }

    /**
     * 比较两个版本，判断当前版本是否小于等于指定版本
     *
     * @param other 要比较的版本
     * @return 如果当前版本小于等于指定版本返回 true，否则返回 false
     */
    public boolean isLessThanOrEqualTo(JavaVersion other) {
        return this.getValue() <= other.getValue();
    }

    /**
     * 判断当前版本是否支持指定的类文件版本
     *
     * @param classVersion 类文件版本号
     * @return 如果当前版本支持指定的类文件版本返回 true，否则返回 false
     */
    public boolean supportsClassVersion(int classVersion) {
        return this.getClassVersion() >= classVersion;
    }

    /**
     * 获取版本之间的差异年数
     *
     * @param other 要比较的版本
     * @return 两个版本之间的差异年数
     */
    public int getYearsDifference(JavaVersion other) {
        return Math.abs(this.getReleaseYear() - other.getReleaseYear());
    }

    /**
     * 获取版本之间的差异版本数
     *
     * @param other 要比较的版本
     * @return 两个版本之间的差异版本数
     */
    public int getVersionDifference(JavaVersion other) {
        return Math.abs((int) (this.getValue() - other.getValue()));
    }

    /**
     * 获取当前版本的下一个版本
     *
     * @return 下一个版本，如果没有下一个版本则返回 null
     */
    public JavaVersion getNext() {
        JavaVersion[] allVersions = getAllReleasedVersions();
        for (int i = 0; i < allVersions.length - 1; i++) {
            if (allVersions[i] == this) {
                return allVersions[i + 1];
            }
        }
        return null;
    }

    /**
     * 获取当前版本的上一个版本
     *
     * @return 上一个版本，如果没有上一个版本则返回 null
     */
    public JavaVersion getPrevious() {
        JavaVersion[] allVersions = getAllReleasedVersions();
        for (int i = 1; i < allVersions.length; i++) {
            if (allVersions[i] == this) {
                return allVersions[i - 1];
            }
        }
        return null;
    }

    /**
     * 获取当前版本的下一个 LTS 版本
     *
     * @return 下一个 LTS 版本，如果没有下一个 LTS 版本则返回 null
     */
    public JavaVersion getNextLts() {
        JavaVersion[] ltsVersions = getLtsVersions();
        for (int i = 0; i < ltsVersions.length - 1; i++) {
            if (ltsVersions[i] == this) {
                return ltsVersions[i + 1];
            }
        }
        return null;
    }

    /**
     * 获取当前版本的上一个 LTS 版本
     *
     * @return 上一个 LTS 版本，如果没有上一个 LTS 版本则返回 null
     */
    public JavaVersion getPreviousLts() {
        JavaVersion[] ltsVersions = getLtsVersions();
        for (int i = 1; i < ltsVersions.length; i++) {
            if (ltsVersions[i] == this) {
                return ltsVersions[i - 1];
            }
        }
        return null;
    }


    /**
     * 判断是否为现代 Java 版本（Java 8 及以上）
     *
     * @return 如果是现代 Java 版本返回 true，否则返回 false
     */
    public boolean isModern() {
        return this.isGreaterThanOrEqualTo(JAVA_1_8);
    }


    /**
     * 判断是否为过时版本（Java 7 及以下）
     *
     * @return 如果是过时版本返回 true，否则返回 false
     */
    public boolean isLegacy() {
        return this.isLessThanOrEqualTo(JAVA_1_7);
    }


}
